home *** CD-ROM | disk | FTP | other *** search
/ Aminet 31 / Aminet 31 (1999)(Schatztruhe)[!][Jun 1999].iso / Aminet / dev / gui / gui4cli.lha / Gui4Cli / Ext / Gui4Cli.h < prev   
C/C++ Source or Header  |  1999-04-21  |  19KB  |  422 lines
  1. /*********************************************************************
  2. **
  3. **    Gui4Cli Include file
  4. **    $VER: 3.6 (20/8/98)
  5. **    Author : D. Keletsekis - dck@hol.gr
  6. **
  7. **    This file holds some of the Gui4Cli internal structures.
  8. **    You can access them by getting a pointer to the GCmain
  9. **    structure (see end of this file) and following the pointers
  10. **    from there.
  11. **
  12. **    The *GCmain pointer is stored in the "gcmain" field of the
  13. **    Gui4Cli message structure, and you can get it by sending 
  14. **    a GM_LOCK message to Gui4Cli, or when Gui4Cli sends you a
  15. **    message (using the CALL command).
  16. **
  17. **    From *GCmain you can see all the gui files, the events,
  18. **    the listviews, the variables, and most of everything that
  19. **    Gui4Cli holds dear. Why you would ever want to, is an 
  20. **    other matter.. Look at the C examples in this directory
  21. **    for information on how to access & manipulate them.
  22. **
  23. *********************************************************************/
  24.  
  25. // union used in events & commands, to hold the arguments, which
  26. // can be numbers or strings - LTWH=numbers, Title=string etc..
  27.  
  28. union commandunion
  29. {  LONG  num;    // if it's a number
  30.    char  *str;   // if it's a string
  31.    APTR  dummy;  // forget it..
  32. };
  33.  
  34. #define OPT_COUNT  12  // max number of arguments 
  35.  
  36. /*********************************************************************
  37.      The Gui4Cli message structure - use it to communicate with G4C
  38. *********************************************************************/
  39.  
  40. struct g4cmsg
  41. {
  42.    struct Message node;    // EXEC message structure
  43.  
  44.    // When Gui4Cli sends the message :
  45.    // - This will be a pointer to the command name which will
  46.    //   have been converted to upper case. If there are any more
  47.    //   arguments passed, then these will be stored in "args[0-5]"
  48.    // When you send a GM_COMMAND or GM_RUN message to Gui4Cli :
  49.    // - This must point to a string buffer which will contain
  50.    //   the command which you want Gui4Cli to execute.
  51.    // otherwise null..
  52.    UBYTE *com;
  53.  
  54.    // This will either contain a pointer to struct *GCmain, or 
  55.    // NULL. You get the pointer when Gui4Cli sends you a
  56.    // message (with the CALL command), or when Gui4Cli replies 
  57.    // to a GM_LOCK message that you sent. Otherwise NULL.
  58.    struct GCmain *gcmain;
  59.  
  60.    // Set this to 392001 which is a "magic" number that Gui4Cli
  61.    // will recognise as being a GC type message.
  62.    LONG  magic;
  63.  
  64.    // 6 argument strings. When Gui4Cli sends you a message, it
  65.    // will consist of a command (which will be in *com above)
  66.    // and up to 6 arguments. This is where the arguments will
  67.    // be stored (if any) - so, if arg[x] is not NULL, it will
  68.    // contain a pointer to a null terminated string.
  69.    UBYTE *args[6];
  70.  
  71.    // if you want to return something, then you must store it
  72.    // in a buffer which you MUST get using AllocVec() and point
  73.    // it here. The buffer will be available from within Gui4Cli
  74.    // as internal variable $$CALL.RET
  75.    // IMPORTANT NOTE:
  76.    // If you attach such a buffer, it will be freed by Gui4Cli, 
  77.    // using FreeVec(), before Gui4Cli sends it's next message.
  78.    UBYTE *msgret;
  79.  
  80.    UBYTE type;        // type of message - see defines below
  81.    LONG  res;        // error status (0 means OK)
  82.    APTR  data;        // null - for future expansion
  83.    APTR  exp;        // null - for future expansion
  84. };
  85.  
  86. /*********************************************************************
  87.      Message types
  88.      These are the currently available types for the "type" field 
  89.      of the above structure.
  90. *********************************************************************/
  91.  
  92. // ------------------------------------------------------------------
  93. // A)  If the command is sent by a program to Gui4Cli:
  94. //   The "com" field must point to a valid command line to be 
  95. //   executed by Gui4Cli - only commands which are defined as 
  96. //   "arexx capable" can be executed. The line will be translated,
  97. //   then parsed and executed. Upon returning, the "res"
  98. //   field will hold the return code, if any was set..
  99. // ---------------------- ...
  100. // B)  If sent by Gui4Cli to an outside program, using CALL :
  101. //   "com" will point to the command name, "gcmain" will contain
  102. //   a pointer to the GCmain structure, and if there are any arguments
  103. //   they will be stored in "args[0]"-"args[5]". Upon return, $$RetCode 
  104. //   will be set to the "res" value you have set (if any). 0 means OK
  105. // ------------------------------------------------------------------
  106. #define GM_COMMAND  1
  107.  
  108. // ------------------------------------------------------------------
  109. // This is the same as GM_COMMAND, Part (A). The difference is that 
  110. // while GM_COMMAND will do the commands synchronously - i.e. the 
  111. // program which sends the command will have to wait until after
  112. // Gui4Cli executes the command to receive the repply, GM_RUN will
  113. // pass the command to Gui4Cli and return and let Gui4Cli get on
  114. // with it asynchronously. The draw back is that you will not know
  115. // when the command finished executing and if it was successful.
  116. // ------------------------------------------------------------------
  117. #define GM_RUN      2
  118.  
  119. // ------------------------------------------------------------------
  120. // GM_LOCK will freeze Gui4Cli, until a GM_UNLOCK message is
  121. // received. When you send a GM_LOCK message, Gui4Cli will immediately
  122. // reply, storing a pointer to the "GCmain" structure in the message's
  123. // "gcmain" field. It will then wait, doing nothing until a GM_UNLOCK
  124. // message is received. Do what you want and then send GM_UNLOCK.
  125. // ------------------------------------------------------------------
  126. #define GM_LOCK        5
  127.  
  128. // ------------------------------------------------------------------
  129. // MUST UNLOCK Gui4Cli after a GM_LOCK message.
  130. // ------------------------------------------------------------------
  131. #define GM_UNLOCK   6
  132.  
  133. /*********************************************************************
  134.     LV helper structures
  135.     these hold various things for listviews..
  136. *********************************************************************/
  137.  
  138. // holds listview colors etc
  139.  
  140. struct styledef
  141. {
  142.    BOOL  usestyle;    // =1 if styles have been specifically set
  143.    WORD  fg;        // foreground pen
  144.    WORD  nbg;           // normal background pen
  145.    WORD  sbg;        // selected background pen
  146.    WORD  shad;        // shadow - signifies to make letters 3D
  147. };
  148.  
  149. // If a LV loads a DataBase file, it allocates a dbdef struct
  150. // and links it to the "db" member of the fulist struct. All
  151. // field definitions are link-listed to this struct.
  152.  
  153. struct lvfield              // field definition struct (AllocVec)
  154. {
  155.    char name[31];         // field name
  156.    LONG start;            // byte in record where field starts
  157.    LONG length;           // field length
  158.    UBYTE type;            // field type (N)umber,(C)har or (D)ate
  159.    struct styledef sd;  // full styledef struct
  160.    struct lvfield *next; // pointer to next field or null
  161.    // ----------- private fields below
  162. };
  163.  
  164. struct dbdef
  165. {
  166.    LONG fieldnum;        // number of fields
  167.    LONG reclength;        // record length
  168.    struct lvfield *topfield;    // linked list of fields (AllocVec)
  169.    // ------------- private fields below
  170. };
  171.  
  172. /*********************************************************************
  173.       LISTVIEW LINE
  174.       Every line of a listview has a structure like this.
  175.       They are kept in a struct List and given to the LV.
  176.       There is a pointer to this list in struct "fulist".
  177.       The LV shows the text pointed to by node->ln_Name.
  178.       This is set to point to some part of the *start buffer,
  179.       according to how much the list is shifted (left/right)
  180. **********************************************************************/
  181.  
  182. struct lister 
  183. { 
  184.   struct Node node;   // a normal exec node for struct List. The ln_Name
  185.                       // field points to the start of the visible text.
  186.   UBYTE *start;       // pointer to the start of the line's text - i.e. the full buffer
  187.   LONG  length;       // line length - buffer is AllocMem (length+1) !!!!
  188.   BOOL Selected;      // 1 = line is selected, 0 = it's not
  189.   struct fulist *fls; // ptr back to parent fulist structure (for hook)
  190.   UBYTE filend;       // pointer to end of filename - for dir listviews
  191.   UBYTE type;         // type of entry - F=file, D=d